package com.atao.baokede.controller;

import com.alipay.api.domain.OrderItem;
import com.atao.baokede.pojo.PageBean;
import com.atao.baokede.pojo.Result;

import com.atao.baokede.pojo.User;
import com.atao.baokede.pojo.UserOrder;
import com.atao.baokede.service.UserService;
import com.atao.baokede.utils.JwtUtil;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Pattern;
import org.hibernate.validator.constraints.URL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.atao.baokede.constant.UserConstant.STATUS_FREEZE;

/**
 * 用户层
 */
@RestController
@RequestMapping("/user")
@Validated
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 用户注册接口
     *
     * @param username 用户名（1-16位）
     * @param password 密码（5-16位）
     * @param email    邮箱
     * @param code     验证码
     * @return 无
     */
    @PostMapping("/register")
    public Result register(@Pattern(regexp = "^\\S{1,16}$") String username,
                           @Pattern(regexp = "^\\S{5,16}$") String password,
                           @Valid @Email String email,
                           String code) {

        String redisCode = (String) redisTemplate.opsForValue().get("registerEmail:" + email);
        System.out.println(redisCode);
        System.out.println(code);
        if (redisCode == null || !redisCode.equals(code)) {
            return Result.error("验证码错误");
        }
        //查询用户
        User u = userService.findByUserEmail(email);
        if (u == null) {
            //没有占用
            //注册
            userService.register(username, password, email);
            return Result.success();
        } else {
            //占用
            return Result.error("邮箱已经注册，请直接登录");
        }
    }

    /**
     * 用户邮箱登录
     *
     * @param email    邮箱
     * @param password 密码
     * @return token
     */
    @PostMapping("/login")
    public Result login(@Valid @Email String email, @Pattern(regexp = "^\\S{5,16}$") String password) {
        //查询用户
        User u = userService.findByUserEmail(email);
        if (u == null) {
            //用户不存在
            return Result.error("用户不存在，请先注册");
        } else if (u.getStatus() == STATUS_FREEZE) {
            //用户被禁用
            return Result.error("该账户已被禁用，请联系管理员");
        } else {
            //检验密码是否正确
            if (!u.getPassword().equals(password)) {
                return Result.error("密码错误");
            }
            //用户存在，登录
            //生成token,并将用户id存到token中
            Map<String, Object> claims = new HashMap<>();
            claims.put("type", "user");
            claims.put("id", u.getId());
            String token = JwtUtil.genToken(claims);
            return Result.success(token);
        }
    }

    /**
     * 验证码登录
     *
     * @param email 邮箱
     * @param code  验证码
     * @return token
     */
    @PostMapping("/codeLogin")
    public Result codeLogin(@Valid @Email String email, String code) {
        // 验证码验证
        String redisCode = (String) redisTemplate.opsForValue().get("loginEmail:" + email);
        if (redisCode == null || !redisCode.equals(code)) {
            return Result.error("验证码错误");
        }
        //查询用户
        User u = userService.findByUserEmail(email);
        if (u == null) {
            //用户不存在
            return Result.error("用户不存在，请先注册");
        } else if (u.getStatus() == STATUS_FREEZE) {
            //用户被禁用
            return Result.error("该账户已被禁用，请联系管理员");
        } else {
            //用户存在，登录
            //生成token,并将用户id存到token中
            Map<String, Object> claims = new HashMap<>();
            claims.put("type", "user");
            claims.put("id", u.getId());
            String token = JwtUtil.genToken(claims);
            return Result.success(token);
        }
    }

    /**
     * 获取用户详细信息
     *
     * @return 用户信息
     */
    @GetMapping("/userInfo")
    public Result<User> userInfo() {
        User u = userService.getUserInfo();
        return Result.success(u);
    }

    /**
     * 更新用户基本信息（不包括头像,密码和手机号）
     *
     * @param user 用户信息
     * @return 无
     */
    @PutMapping("/update")
    public Result update(@RequestBody User user) {
        userService.update(user);
        return Result.success();
    }

    /**
     * 更新用户头像
     *
     * @param avatarUrl 头像地址
     * @return 无
     */
    @PatchMapping("/updateAvatar")
    public Result updateAvatar(@RequestParam @URL String avatarUrl) throws Exception {
        userService.updateAvatar(avatarUrl);
        return Result.success();
    }

    /**
     * 更新用户密码
     *
     * @param newPwd 新密码
     * @param rePwd  再次输入新密码
     * @param email  邮箱
     * @param code   验证码
     * @return 无
     */
    @PatchMapping("/updatePwd")
    public Result updatePwd(@RequestParam @Pattern(regexp = "^\\S{5,16}$") String newPwd,
                            @RequestParam @Pattern(regexp = "^\\S{5,16}$") String rePwd,
                            @RequestParam @Email String email,
                            String code) {
        //检测两次输入的密码是否一致
        if (!newPwd.equals(rePwd)) {
            return Result.error("两次输入的密码不一致");
        }
        String redisCode = (String) redisTemplate.opsForValue().get("updatePwdEmail:" + email);
        if (redisCode == null || !redisCode.equals(code)) {
            return Result.error("验证码错误");
        }
        userService.updatePwd(email, newPwd);
        return Result.success();
    }

    /**
     * 查看商品购买订单
     *
     * @param status   状态（0：代付款，1：已支付，2：已取消）（非必须，不传查全部）
     * @param order_id 订单id（非必须）
     * @param item_name 商品名称（非必须）
     * @param pageNum  页码
     * @param pageSize 每页数量
     */
    @GetMapping("/getUserOrders")
    public Result<PageBean<UserOrder>> getUserOrders(
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) Integer order_id,
            @RequestParam(required = false) String item_name,
            @RequestParam Integer pageNum,
            @RequestParam Integer pageSize)
    {
        return Result.success(userService.getUserOrders(status,order_id,item_name, pageNum, pageSize));
    }
}